#include "operand.h"
#include "ring.h"

Ciphertext::Ciphertext(Context *parameters, int degree, int level) : Operand(MultiType::ciphertext)
{
    value.resize(degree + 1);
    for (int i = 0; i < degree + 1; i++) {
        value[i] = new Poly(parameters->N(), level + 1);
    }
}

Ciphertext::Ciphertext(uint64_t N, int degree, int level) : Operand(MultiType::ciphertext)
{
    value.resize(degree + 1);
    for (int i = 0; i < degree + 1; i++) {
        value[i] = new Poly(N, level + 1);
    }
}
Ciphertext::Ciphertext() : Operand(MultiType::ciphertext) {}
Ciphertext::Ciphertext(Plaintext plaintext) : Operand(MultiType::ciphertext)
{
    value.push_back(plaintext.value);
}
/*
 * @brief 返回指向当前 `Ciphertext` 对象的指针。
 * @return 指向当前 `Ciphertext` 对象的指针。
 */
Ciphertext *Ciphertext::El()
{
    return this;
}
/*
 * @brief 返回指向当前 `Ciphertext` 对象的度，即多项式的数量。
 * @return 指向当前 `Ciphertext` 对象的多项式数量。
 */
int Ciphertext::Degree()
{
    return value.size() - 1;
}
/*
 * @brief 返回指向当前 `Ciphertext` 对象的级数，即多项式中系数的数量 - 1。
 * @return 指向当前 `Ciphertext` 对象的级数。
 */
int Ciphertext::Level()
{
    return value[0]->Coeffs.size() - 1;
}
/*
 * @brief 将当前 `Ciphertext` 对象的值复制到另一个 `Ciphertext` 对象。
 * @param ctxCopy 目标 `Ciphertext` 对象。
 */
void Ciphertext::Copy(Ciphertext *ctxCopy)
{
    if (this != ctxCopy) {
        for (uint64_t i = 0; i < ctxCopy->value.size(); i++) {
            this->value[i]->Copy(ctxCopy->value[i]);
        }
    }
}

Ciphertext &Ciphertext::operator = (const Ciphertext &other)
{
    if (this == &other) { // 防止自我赋值
        return *this;
    }

    // 调用基类的赋值（如果基类有需要拷贝的内容）
    Operand::operator = (other);

    // 复制非动态分配的成员
    this->type = other.type;

    // 清空当前对象中的动态分配资源
    for (Poly *poly : value) {
        delete poly; // 释放动态分配的内存
    }
    value.clear();

    // 深拷贝 `value` 中的元素
    for (Poly *poly : other.value) {
        value.push_back(new Poly(*poly)); // 假设 Poly 类有拷贝构造函数
    }
    return *this;
}
/*
 * @brief 返回指向当前 `Ciphertext` 对象的系数数量，即多项式中系数的数量。
 * @return 指向当前 `Ciphertext` 对象的系数数量。
 */
int Ciphertext::CoeffCount()
{
    return value[0]->Coeffs[0].size();
}

Plaintext::Plaintext(Context *parameters, int level) : Operand(MultiType::plaintext)
{
    value = new Poly(parameters->N(), level + 1);
}

Plaintext::Plaintext(uint64_t N, int level) : Operand(MultiType::plaintext)
{
    value = new Poly(N, level + 1);
}

Ciphertext *Plaintext::El()
{
    return new Ciphertext(*this);
}

int Plaintext::Degree()
{
    return 0;
}

int Plaintext::Level()
{
    return value->Coeffs.size() - 1;
}

Plaintext::Plaintext(std::vector<uint64_t> in, int level) : Operand(MultiType::plaintext)
{
    uint64_t N = in.size();
    value = new Poly(N, level + 1);
    for (int i = 0; i < N; i++) {
        value->Coeffs[0][i] = in[i];
    }
}

Plaintext::Plaintext() : Operand(MultiType::plaintext) {}
/*
 * @brief 返回指向当前 `Plaintext` 对象的系数数量，即多项式中系数的数量。
 * @return 指向当前 `Plaintext` 对象的系数数量。
 */
int Plaintext::CoeffCount()
{
    return value->Coeffs[0].size();
}
